#pragma once
/************************************************************************/
/* 转载自网络.                                                                     */
/************************************************************************/
#include <list>

	//具有6个参数的事件类模板----------------------------------------------------------------------------------------------------------------------------------------------------------
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
#define TYPES_DECLARE typename param1=void,typename param2=void,typename param3=void,typename param4=void,typename param5=void,typename param6=void
#define ALL_TYPES param1 ,param2 ,param3 ,param4 ,param5 ,param6
#define PARAMS_DECLARE param1 p1,param2 p2,param3 p3,param4 p4,param5 p5,param6 p6
#define PARAMS p1,p2,p3,p4,p5,p6
	//函数调用类抽象接口
	template<TYPES_DECLARE>
	class FunctionInterface
	{
	public:
		virtual void* GetClassHandler()=0;
		virtual void* GetFunHandler()=0;
		virtual void Invoke(ALL_TYPES)=0;
	};


	//全局函数调用类
	template<TYPES_DECLARE>
	class GolobalFunction:public FunctionInterface<ALL_TYPES>
	{
	public:
		typedef void(*T_HANDLER)(ALL_TYPES);
	protected:
		union
		{
			T_HANDLER FuncHandler;
			void*   pFPointer;
		};

	public:   
		GolobalFunction(T_HANDLER f)
		{
			FuncHandler=f;
		}
		void *GetClassHandler()
		{
			return 0;
		}
		void *GetFunHandler()
		{
			return pFPointer;
		}
		void Invoke(PARAMS_DECLARE)
		{
			(*FuncHandler)(PARAMS);
		}
	};

	//成员函数调用类
	template<typename Class,TYPES_DECLARE>
	class MemberFunction:public FunctionInterface<ALL_TYPES>
	{
	public:
		typedef void(Class::*T_HANDLER)(ALL_TYPES);
	protected:
		union
		{
			T_HANDLER FuncHandler;
			void *  pFPointer;
		};
		union
		{
			Class *OwnClassHandler;
			void * pCPointer;
		};

	public:
		MemberFunction(Class *pClass,T_HANDLER f)
		{
			OwnClassHandler=pClass;
			FuncHandler=f;
		}
		void *GetClassHandler()
		{
			return pCPointer;
		}
		void *GetFunHandler()
		{
			return pFPointer;
		}
		void Invoke(PARAMS_DECLARE)
		{
			(OwnClassHandler->*FuncHandler)(PARAMS);
		}
	};


	//事件封装
	template<TYPES_DECLARE>
	class Event
	{
	protected:
		typedef std::list< FunctionInterface<ALL_TYPES>*> T_FUNCTIONLIST;
		typedef typename T_FUNCTIONLIST::iterator T_FUNCTION_ITERATOR;

		T_FUNCTIONLIST FunctionList;

	private:
		T_FUNCTION_ITERATOR Find(FunctionInterface<ALL_TYPES>* target)
		{
			void *temp1=target->GetClassHandler();
			void *temp2=target->GetFunHandler();
			T_FUNCTION_ITERATOR i=FunctionList.begin();
			for (;i!=FunctionList.end();++i)
			{
				if (temp1==(*i)->GetClassHandler()  &&  temp2==(*i)->GetFunHandler())
				{
					break;
				}
			}
			return i;
		}
	public:
		inline void Invoke(PARAMS_DECLARE)
		{
			T_FUNCTION_ITERATOR i=FunctionList.begin();
			for (;i!=FunctionList.end();++i)
			{
				(*i)->Invoke(PARAMS);
			}
		}

		void Bind(typename GolobalFunction<ALL_TYPES>::T_HANDLER gFuncHandle)
		{
			GolobalFunction<ALL_TYPES>*addone=new GolobalFunction<ALL_TYPES>(gFuncHandle);
			if(Find(addone)!=FunctionList.end())//已经存在了,就不需要添加
				delete addone;//删除临时的new对象
			else
				FunctionList.push_back(addone);
		}
		void UnBind(typename GolobalFunction<ALL_TYPES>::T_HANDLER gFuncHandle)
		{
			GolobalFunction<ALL_TYPES>*delone=new GolobalFunction<ALL_TYPES>(gFuncHandle);
			T_FUNCTION_ITERATOR delnode=Find(delone);
			if (delnode!=FunctionList.end())//存在，删除节点和指针
			{
				delete (*delnode);
				FunctionList.erase(delnode);
			}
			delete delone;//删除临时的new对象
		}
		template<typename Class>
		void Bind(Class *classHandle,typename MemberFunction<Class,ALL_TYPES>::T_HANDLER mFuncHandle)
		{
			MemberFunction<Class,ALL_TYPES>*addone=new MemberFunction<Class,ALL_TYPES>(classHandle,mFuncHandle);
			if (Find(addone)!=FunctionList.end())//已经存在
				delete addone;//删除临时的new对象
			else
				FunctionList.push_back(addone);
		}
		template<typename Class>
		void UnBind(Class *classHandle,typename MemberFunction<Class,ALL_TYPES>::T_HANDLER mFuncHandle)
		{
			MemberFunction<Class,ALL_TYPES>*delone=new MemberFunction<Class,ALL_TYPES>(classHandle,mFuncHandle);
			T_FUNCTION_ITERATOR delnode=Find(delone);
			if (delnode!=FunctionList.end())//存在，删除节点和指针
			{
				delete (*delnode);
				FunctionList.erase(delnode);
			}
			delete delone;//删除临时的new对象
		}
		void operator()(PARAMS_DECLARE)
		{
			Invoke(PARAMS);
		}
		~Event()
		{
			T_FUNCTION_ITERATOR i=FunctionList.begin();
			for (;i!=FunctionList.end();++i)
			{
				delete (*i);
			}
		}
	};



	//局部特化具有5个参数的事件类模板
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
#undef TYPES_DECLARE
#undef ALL_TYPES
#undef PARAMS_DECLARE
#undef PARAMS

#define TYPES_DECLARE typename param1,typename param2,typename param3,typename param4,typename param5
#define ALL_TYPES param1,param2,param3,param4,param5,void
#define USEFUL_TYPES param1,param2,param3,param4,param5
#define PARAMS_DECLARE param1 p1,param2 p2,param3 p3,param4 p4,param5 p5
#define PARAMS p1,p2,p3,p4,p5

#include "EventHelp.h"

	//局部特化具有4个参数的事件类模板
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
#undef TYPES_DECLARE
#undef ALL_TYPES
#undef USEFUL_TYPES
#undef PARAMS_DECLARE
#undef PARAMS

#define TYPES_DECLARE typename param1,typename param2,typename param3,typename param4
#define ALL_TYPES param1,param2,param3,param4,void,void
#define USEFUL_TYPES param1,param2,param3,param4
#define PARAMS_DECLARE param1 p1,param2 p2,param3 p3,param4 p4
#define PARAMS p1,p2,p3,p4

#include "EventHelp.h"

	//局部特化具有3个参数的事件类模板
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
#undef TYPES_DECLARE
#undef ALL_TYPES
#undef USEFUL_TYPES
#undef PARAMS_DECLARE
#undef PARAMS

#define TYPES_DECLARE typename param1,typename param2,typename param3
#define ALL_TYPES param1,param2,param3,void,void,void
#define USEFUL_TYPES param1,param2,param3
#define PARAMS_DECLARE param1 p1,param2 p2,param3 p3
#define PARAMS p1,p2,p3

#include "EventHelp.h"

	//局部特化具有2个参数的事件类模板
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
#undef TYPES_DECLARE
#undef ALL_TYPES
#undef USEFUL_TYPES
#undef PARAMS_DECLARE
#undef PARAMS

#define TYPES_DECLARE typename param1,typename param2
#define ALL_TYPES param1,param2,void,void,void,void
#define USEFUL_TYPES param1,param2
#define PARAMS_DECLARE param1 p1,param2 p2
#define PARAMS p1,p2

#include "EventHelp.h"

	//局部特化具有1个参数的事件类模板
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
#undef TYPES_DECLARE
#undef ALL_TYPES
#undef USEFUL_TYPES
#undef PARAMS_DECLARE
#undef PARAMS

#define TYPES_DECLARE typename param1
#define ALL_TYPES param1,void,void,void,void,void
#define USEFUL_TYPES param1
#define PARAMS_DECLARE param1 p1
#define PARAMS p1

#include "EventHelp.h"

	//局部特化具有0个参数的事件类模板
	//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
	template<>
	class FunctionInterface<void,void,void,void,void,void>
	{
	public:
		virtual void* GetClassHandler()=0;
		virtual void* GetFunHandler()=0;
		virtual void Invoke()=0;
	};


	//全局函数调用类特化
	template<>
	class GolobalFunction<void,void,void,void,void,void>:public FunctionInterface<>
	{
	public:
		typedef void(*T_HANDLER)();
	protected:
		union
		{
			T_HANDLER FuncHandler;
			void*   pFPointer;
		};

	public:   
		GolobalFunction(T_HANDLER f)
		{
			FuncHandler=f;
		}
		void *GetClassHandler()
		{
			return 0;
		}
		void *GetFunHandler()
		{
			return pFPointer;
		}
		void Invoke()
		{
			(*FuncHandler)();
		}
	};

	//成员函数调用类特化
	template<typename Class>
	class MemberFunction<typename Class,void,void,void,void,void,void>:public FunctionInterface<>
	{
	public:
		typedef void(Class::*T_HANDLER)();
	protected:
		union
		{
			T_HANDLER FuncHandler;
			void *  pFPointer;
		};
		union
		{
			Class *OwnClassHandler;
			void * pCPointer;
		};

	public:
		MemberFunction(Class *pClass,T_HANDLER f)
		{
			OwnClassHandler=pClass;
			FuncHandler=f;
		}
		void *GetClassHandler()
		{
			return pCPointer;
		}
		void *GetFunHandler()
		{
			return pFPointer;
		}
		void Invoke()
		{
			(OwnClassHandler->*FuncHandler)();
		}
	};


	//事件类特化
	template<>
	class Event<void,void,void,void,void,void>
	{
	protected:
		typedef std::list< FunctionInterface<>*> T_FUNCTIONLIST;
		typedef T_FUNCTIONLIST::iterator T_FUNCTION_ITERATOR;

		T_FUNCTIONLIST FunctionList;

	private:
		T_FUNCTION_ITERATOR Find(FunctionInterface<>* target)
		{
			void *temp1=target->GetClassHandler();
			void *temp2=target->GetFunHandler();
			T_FUNCTION_ITERATOR i=FunctionList.begin();
			for (;i!=FunctionList.end();++i)
			{
				if (temp1==(*i)->GetClassHandler()  &&  temp2==(*i)->GetFunHandler())
				{
					break;
				}
			}
			return i;
		}
	public:
		inline void Invoke()
		{
			T_FUNCTION_ITERATOR i=FunctionList.begin();
			for (;i!=FunctionList.end();++i)
			{
				(*i)->Invoke();
			}
		}

		void Bind(GolobalFunction<>::T_HANDLER gFuncHandle)
		{
			GolobalFunction<>*addone=new GolobalFunction<>(gFuncHandle);
			if(Find(addone)!=FunctionList.end())//已经存在了,就不需要添加
				delete addone;//删除临时的new对象
			else
				FunctionList.push_back(addone);
		}
		void UnBind(GolobalFunction<>::T_HANDLER gFuncHandle)
		{
			GolobalFunction<>*delone=new GolobalFunction<>(gFuncHandle);
			T_FUNCTION_ITERATOR delnode=Find(delone);
			if (delnode!=FunctionList.end())//存在，删除节点和指针
			{
				delete (*delnode);
				FunctionList.erase(delnode);
			}
			delete delone;//删除临时的new对象
		}
		template<typename Class>
		void Bind(Class *classHandle,typename MemberFunction<Class>::T_HANDLER mFuncHandle)
		{
			MemberFunction<Class>*addone=new MemberFunction<Class>(classHandle,mFuncHandle);
			if (Find(addone)!=FunctionList.end())//已经存在
				delete addone;//删除临时的new对象
			else
				FunctionList.push_back(addone);
		}
		template<typename Class>
		void UnBind(Class *classHandle,typename MemberFunction<Class>::T_HANDLER mFuncHandle)
		{
			MemberFunction<Class>*delone=new MemberFunction<Class>(classHandle,mFuncHandle);
			T_FUNCTION_ITERATOR delnode=Find(delone);
			if (delnode!=FunctionList.end())//存在，删除节点和指针
			{
				delete (*delnode);
				FunctionList.erase(delnode);
			}
			delete delone;//删除临时的new对象
		}
		void operator()()
		{
			Invoke();
		}
		~Event()
		{
			T_FUNCTION_ITERATOR i=FunctionList.begin();
			for (;i!=FunctionList.end();++i)
			{
				delete (*i);
			}
		}
	};
